﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Sisocana.Core.Interfaces;
using Sisocana.Dal.EntityModels;
using Sisocana.Core.Models;
using Sisocana.Dal.Interfaces;
using Sisocana.Dal;

namespace Sisocana.Core
{
    public class WSBusquedaService : IWSBusquedaService
    {
        private IWSBusquedaRepository _busquedaRepository;

        public WSBusquedaService()
            : this(new WSBusquedaRepository())
        {
        }

        public WSBusquedaService(IWSBusquedaRepository busquedaRepository)
        {
            _busquedaRepository = busquedaRepository;
        }


        public void createWSBusquedaMapperEF2Model()
        {
            AutoMapper.Mapper.CreateMap<WsBusqueda, WSBusquedaModel>()
                .ForMember(s => s.idSitio, opt => opt.MapFrom(c => c.Sitio.id));
        }

        public void createWSBusquedaMapperModel2EF()
        {
            AutoMapper.Mapper.CreateMap<WSBusquedaModel, WsBusqueda>();
        }

        public int createWSBusqueda(WSBusquedaModel ws)
        {
            createWSBusquedaMapperModel2EF();
            WsBusqueda wsEF = new WsBusqueda();
            wsEF = AutoMapper.Mapper.Map(ws, wsEF);

            SiteRepository _SiteRepository = new SiteRepository();
            Sitio sitEF = _SiteRepository.GetSingle(c => c.id == ws.idSitio);

            wsEF.Sitio = sitEF;

            _busquedaRepository.Add(wsEF);
            
            try
            {
                _busquedaRepository.Save();
                return 0;
            }
            catch (Exception e)
            {
                return e.InnerException.GetHashCode();
            }
        }

        public int updateWSBusqueda(WSBusquedaModel ws)
        {
            createWSBusquedaMapperModel2EF();
            WsBusqueda wsEF = _busquedaRepository.GetSingle(w => w.id == ws.id);
            wsEF = AutoMapper.Mapper.Map(ws, wsEF);

            try
            {
                _busquedaRepository.Save();
                return 0;
            }
            catch (Exception e)
            {
                return e.InnerException.GetHashCode();
            }
        }

        public int deleteWSBusqueda(WSBusquedaModel wsbm)
        {
            WsBusqueda wsb = _busquedaRepository.GetSingle(c => c.id == wsbm.id);

            if (wsb == null)
                return -2;

            try
            {
                _busquedaRepository.Delete(wsb);
                _busquedaRepository.Save();
                return 0;
            }
            catch (Exception e)
            {
                return e.InnerException.GetHashCode();
            }
        }

        Models.WSBusquedaModel IService<Models.WSBusquedaModel>.GetSingle(System.Linq.Expressions.Expression<Func<Models.WSBusquedaModel, bool>> whereCondition)
        {
            createWSBusquedaMapperEF2Model();

            IList<WsBusqueda> wsEF = _busquedaRepository.GetAll();
            List<WSBusquedaModel> ws = new List<WSBusquedaModel>();
            ws = AutoMapper.Mapper.Map(wsEF, ws);
            IQueryable<WSBusquedaModel> wsRet = ws.AsQueryable<WSBusquedaModel>().Where(whereCondition);
            if (wsRet.Count() == 0)
                return null;

            return wsRet.ToList().First();
        }

        void IService<Models.WSBusquedaModel>.Add(Models.WSBusquedaModel entity)
        {
            throw new NotImplementedException();
        }

        void IService<Models.WSBusquedaModel>.Delete(Models.WSBusquedaModel entity)
        {
            throw new NotImplementedException();
        }

        void IService<Models.WSBusquedaModel>.Update(Models.WSBusquedaModel entity)
        {
            throw new NotImplementedException();
        }

        IList<Models.WSBusquedaModel> IService<Models.WSBusquedaModel>.GetAll(System.Linq.Expressions.Expression<Func<Models.WSBusquedaModel, bool>> whereCondition)
        {
            createWSBusquedaMapperEF2Model();

            IList<WsBusqueda> wsEF = _busquedaRepository.GetAll();
            List<WSBusquedaModel> ws = new List<WSBusquedaModel>();
            ws = AutoMapper.Mapper.Map(wsEF, ws);
            IQueryable<WSBusquedaModel> wsRet = ws.AsQueryable<WSBusquedaModel>().Where(whereCondition);
            return wsRet.ToList();

        }

        IList<Models.WSBusquedaModel> IService<Models.WSBusquedaModel>.GetAll()
        {
            throw new NotImplementedException();
        }

        IQueryable<Models.WSBusquedaModel> IService<Models.WSBusquedaModel>.Query(System.Linq.Expressions.Expression<Func<Models.WSBusquedaModel, bool>> whereCondition)
        {
            throw new NotImplementedException();
        }

        long IService<Models.WSBusquedaModel>.Count(System.Linq.Expressions.Expression<Func<Models.WSBusquedaModel, bool>> whereCondition)
        {
            throw new NotImplementedException();
        }

        long IService<Models.WSBusquedaModel>.Count()
        {
            throw new NotImplementedException();
        }
    }
}
